/*
Copyright (c) 2009 David Bucciarelli (davibu@interfree.it)

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

/*
 * Based on smallpt, a Path Tracer by Kevin Beason, 2008
 * Modified by David Bucciarelli to show the output via OpenGL/GLUT, ported
 * to C, work with float, fixed RR, ported to OpenCL, etc.
 */

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <math.h>
#include <unistd.h>

#include "camera.h"
#include "scene.h"
#include "displayfunc.h"

int workGroupSize = 1;

static Vec *colors;
static unsigned int *seeds;
Camera camera;
static int currentSample = 0;
Sphere *spheres;
unsigned int sphereCount;
static float totalTime = 0;







void FreeBuffers() {
	free(seeds);
	free(colors);
	free(pixels);
}

//Inizializzazione dei buffer
void AllocateBuffers() {
	const int pixelCount = height * width ;
	int i;
	colors = malloc(sizeof(Vec[pixelCount])); //Dimensione dell'immagine

	seeds = malloc(sizeof(unsigned int[pixelCount * 2]));
	for (i = 0; i < pixelCount * 2; i++) {
		seeds[i] = rand();
		if (seeds[i] < 2)
			seeds[i] = 2;
	}

	pixels = malloc(sizeof(unsigned int[pixelCount]));
}

/* --UpdateRendering--
 * Main del rendering,
 * Scorre tutta l'immagine pixel per pixel
 * Lancia il raggio calcolandone la direzione
 * Richiama la funzione di Path Tracing
 * Converte il valore di radianza trovato in modo da poterlo mostrare nel modello RGB
 * */
void UpdateRendering(void) {
	double startTime = WallClockTime();

	const float invWidth = 1.f / width;
	const float invHeight = 1.f / height;

	int x, y;
	//Scorre l'immagine pixel per pixel
	for (y = 0; y < height; y++) { /* Loop over image rows */
		for (x = 0; x < width; x++) { /* Loop cols */
			const int i = (height - y - 1) * width + x; //indice del pixel
			const int i2 = 2 * i;
			const float r1 = GetRandom(&seeds[i2], &seeds[i2 + 1]) - .5f; //r1 e r2 sono valori random del tent filter
			const float r2 = GetRandom(&seeds[i2], &seeds[i2 + 1]) - .5f;
			const float kcx = (x + r1) * invWidth - .5f;
			const float kcy = (y + r2) * invHeight - .5f;

			//Calcolo della direzione del raggio in base a cx,cy e camera
			Vec rdir;
			vinit(rdir,
				camera.x.x * kcx + camera.y.x * kcy + camera.dir.x,
				camera.x.y * kcx + camera.y.y * kcy + camera.dir.y,
				camera.x.z * kcx + camera.y.z * kcy + camera.dir.z);

			Vec rorig;
			vsmul(rorig, 0.1f, rdir);
			vadd(rorig, rorig, camera.orig)

			vnorm(rdir);
			const Ray ray = {rorig, rdir};
			Vec r;

			RadiancePathTracing(spheres, sphereCount, &ray,
					&seeds[i2], &seeds[i2 + 1],&r);

			//RadianceDirectLighting(spheres, sphereCount, &ray,
			//		&seeds[i2], &seeds[i2+1], &r);
			if (currentSample == 0)
				colors[i] = r;
			else {
				const float k1 = currentSample;
				const float k2 = 1.f / (k1 + 1.f);
				//k1 e k2 dovrebbero essere una correzione di gamma
				colors[i].x = (colors[i].x * k1 + r.x) * k2;
				colors[i].y = (colors[i].y * k1 + r.y) * k2;
				colors[i].z = (colors[i].z * k1 + r.z) * k2;
			}

			//Si converte il valore di radianza calcolato per farlo rientrare nel range 0-255 del modello RGB
			pixels[y * width + x] = toInt(colors[i].x) |
					(toInt(colors[i].y) << 8) |
					(toInt(colors[i].z) << 16);
		}
	}

	const float elapsedTime = WallClockTime() - startTime;
	const float sampleSec = height * width / elapsedTime;
	totalTime += elapsedTime;
	sprintf(captionBuffer, "RT %.3f sec (pass %d)  s/s  %.1fK\n TT %.2f sec PM %.3f",
		elapsedTime, currentSample, sampleSec / 1000.f,totalTime,path_medio);

	currentSample++;
	printf("CS:%d\n",currentSample);
	if (currentSample == 100) for(;;)printf("Sono nel loop con CS:%d\n",currentSample);
}

void ReInitScene() {
	currentSample = 0;
}

void ReInit(const int reallocBuffers) {
	// Check if I have to reallocate buffers
	if (reallocBuffers) {
		FreeBuffers();
		AllocateBuffers();
	}

	UpdateCamera();
	currentSample = 0;
	UpdateRendering();
}


/* --main--
 * Il main si occupa di aggregare tutte le funzioni di inizializzazione
 * ed esecuzione necessarie alla corretta esecuzione del software.
 * Richiama la funzione per il caricamente della scena (in alternativa, imposta quella di default)
 * Richiama le funzioni di inizializzazione della fotocamera e dei buffer necessari alla
 * visualizzazione dell'immagine.
 * Richiama l'inizializzazione per l'ambiente OpenGL
 * */
int main(int argc, char *argv[]) {
	amiSmallptCPU = 1;

	//Il software vuole in input dimesione della finestra GLUT e un file che descrivere la scena da realizzare
        fprintf(stderr, "Usage: %s\n", argv[0]);
	fprintf(stderr, "Usage: %s <window width> <window height> <scene file>\n", argv[0]);


        //Conversione degli input
	if (argc == 4) {
		width = atoi(argv[1]);
		height = atoi(argv[2]);
		ReadScene(argv[3]); //Legge il file della scena, ReadScene si occupa di riempire la struttura della scena
	} else if (argc == 1) { //Nel caso non venga passata una scena in input, imposta quella di default (CornellSpheres)
		spheres = CornellSpheres;
                //Rapporto tra il numero di sfere della scena di default e Sphere ???
    	sphereCount = sizeof(CornellSpheres) / sizeof(Sphere);

                //Posizionamento della fotocamera, Posizione e Direzione

    	// cornell sphere
    	vinit(camera.orig, 50.f, 45.f, 205.6f);
    	// nightsky vinit(camera.orig, 50.f, 40.8f, 206);
		// island vinit(camera.orig, 50.f, 37, -305);


		//cornell sphere
    	vinit(camera.target, 50.f, 45 - 0.042612f, 204.6);
		//nightsky vinit(camera.target, 50.f, 45 - 0.042612f, 0);
        //island vinit(camera.target, 50.f, -10.5, -1100);

	} else
		exit(-1);

	UpdateCamera();

	/*------------------------------------------------------------------------*/

	AllocateBuffers();

	/*------------------------------------------------------------------------*/

	InitGlut(argc, argv, "SmallPT CPU V1.6 (Written by David Bucciarelli)");

    glutMainLoop( );

	return 0;
}
